జావాస్క్రిప్ట్ అసింక్ లోకల్ స్టోరేజ్: రిక్వెస్ట్-స్కోప్డ్ కాంటెక్స్ట్ మేనేజ్‌మెంట్‌పై పట్టు సాధించడం

అసమకాలిక జావాస్క్రిప్ట్ ప్రపంచంలో, వివిధ ఆపరేషన్లలో కాంటెక్స్ట్‌ను నిర్వహించడం ఒక సంక్లిష్టమైన సవాలుగా మారుతుంది. ఫంక్షన్ కాల్స్ ద్వారా కాంటెక్స్ట్ ఆబ్జెక్ట్‌లను పంపడం వంటి సాంప్రదాయ పద్ధతులు తరచుగా పెద్ద మరియు గజిబిజి కోడ్‌కు దారితీస్తాయి. అదృష్టవశాత్తూ, జావాస్క్రిప్ట్ అసింక్ లోకల్ స్టోరేజ్ (ALS) అసమకాలిక వాతావరణంలో రిక్వెస్ట్-స్కోప్డ్ కాంటెక్స్ట్‌ను నిర్వహించడానికి ఒక సొగసైన పరిష్కారాన్ని అందిస్తుంది. ఈ వ్యాసం ALS యొక్క సూక్ష్మ నైపుణ్యాలను పరిశోధిస్తుంది, దాని ప్రయోజనాలు, అమలు మరియు వాస్తవ-ప్రపంచ వినియోగ సందర్భాలను అన్వేషిస్తుంది.

అసింక్ లోకల్ స్టోరేజ్ అంటే ఏమిటి?

అసింక్ లోకల్ స్టోరేజ్ (ALS) అనేది ఒక నిర్దిష్ట అసమకాలిక ఎగ్జిక్యూషన్ కాంటెక్స్ట్‌కు స్థానికంగా ఉండే డేటాను నిల్వ చేయడానికి మిమ్మల్ని అనుమతించే ఒక యంత్రాంగం. ఈ కాంటెక్స్ట్ సాధారణంగా ఒక రిక్వెస్ట్ లేదా లావాదేవీతో అనుబంధించబడి ఉంటుంది. దీనిని Node.js వంటి అసమకాలిక జావాస్క్రిప్ట్ వాతావరణాల కోసం థ్రెడ్-లోకల్ స్టోరేజ్ సమానమైనదాన్ని సృష్టించే మార్గంగా భావించండి. సాంప్రదాయ థ్రెడ్-లోకల్ స్టోరేజ్ (ఇది సింగిల్-థ్రెడెడ్ జావాస్క్రిప్ట్‌కు నేరుగా వర్తించదు) వలె కాకుండా, ALS అసమకాలిక ప్రిమిటివ్‌లను ఉపయోగించుకుని, స్పష్టంగా ఆర్గ్యుమెంట్‌లుగా పంపకుండానే అసమకాలిక కాల్స్ అంతటా కాంటెక్స్ట్‌ను ప్రచారం చేస్తుంది.

ALS వెనుక ఉన్న ప్రధాన ఆలోచన ఏమిటంటే, ఒక నిర్దిష్ట అసమకాలిక ఆపరేషన్ లోపల (ఉదా. వెబ్ రిక్వెస్ట్‌ను నిర్వహించడం), మీరు ఆ నిర్దిష్ట ఆపరేషన్‌కు సంబంధించిన డేటాను నిల్వ చేయవచ్చు మరియు తిరిగి పొందవచ్చు, ఇది వేర్వేరు ఏకకాల అసమకాలిక పనుల మధ్య వేరుచేయడాన్ని నిర్ధారిస్తుంది మరియు కాంటెక్స్ట్ కాలుష్యాన్ని నివారిస్తుంది.

అసింక్ లోకల్ స్టోరేజ్ ఎందుకు ఉపయోగించాలి?

ఆధునిక జావాస్క్రిప్ట్ అప్లికేషన్‌లలో అసింక్ లోకల్ స్టోరేజ్‌ను స్వీకరించడానికి అనేక బలమైన కారణాలు ఉన్నాయి:

• సరళీకృత కాంటెక్స్ట్ నిర్వహణ: బహుళ ఫంక్షన్ కాల్స్ ద్వారా కాంటెక్స్ట్ ఆబ్జెక్ట్‌లను పంపడం నివారించండి, కోడ్ పరిమాణాన్ని తగ్గించడం మరియు చదవడానికి సులభంగా చేయడం.
• మెరుగైన కోడ్ నిర్వహణ: కాంటెక్స్ట్ నిర్వహణ లాజిక్‌ను కేంద్రీకరించడం, అప్లికేషన్ కాంటెక్స్ట్‌ను సవరించడం మరియు నిర్వహించడం సులభం చేస్తుంది.
• మెరుగైన డీబగ్గింగ్ మరియు ట్రేసింగ్: మీ అప్లికేషన్ యొక్క వివిధ పొరల ద్వారా రిక్వెస్ట్‌లను ట్రేస్ చేయడానికి రిక్వెస్ట్-నిర్దిష్ట సమాచారాన్ని ప్రచారం చేయండి.
• మిడిల్‌వేర్‌తో అతుకులు లేని ఇంటిగ్రేషన్: Express.js వంటి ఫ్రేమ్‌వర్క్‌లలోని మిడిల్‌వేర్ నమూనాలతో ALS బాగా కలిసిపోతుంది, రిక్వెస్ట్ జీవితచక్రం ప్రారంభంలోనే కాంటెక్స్ట్‌ను సంగ్రహించడానికి మరియు ప్రచారం చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.
• బాయిలర్‌ప్లేట్ కోడ్ తగ్గించడం: దీనికి అవసరమైన ప్రతి ఫంక్షన్‌లో స్పష్టంగా కాంటెక్స్ట్‌ను నిర్వహించాల్సిన అవసరాన్ని తొలగించండి, ఇది శుభ్రమైన మరియు మరింత దృష్టి కేంద్రీకరించిన కోడ్‌కు దారితీస్తుంది.

ప్రధాన భావనలు మరియు API

Node.js (వెర్షన్ 13.10.0 మరియు అంతకంటే ఎక్కువ)లో `async_hooks` మాడ్యూల్ ద్వారా అందుబాటులో ఉన్న అసింక్ లోకల్ స్టోరేజ్ API, కింది కీలక భాగాలను అందిస్తుంది:

• `AsyncLocalStorage` క్లాస్: అసమకాలిక నిల్వ సందర్భాలను సృష్టించడానికి మరియు నిర్వహించడానికి కేంద్ర తరగతి.
• `run(store, callback, ...args)` మెథడ్: ఒక నిర్దిష్ట అసమకాలిక కాంటెక్స్ట్‌లో ఒక ఫంక్షన్‌ను అమలు చేస్తుంది. `store` ఆర్గ్యుమెంట్ కాంటెక్స్ట్‌తో అనుబంధించబడిన డేటాను సూచిస్తుంది, మరియు `callback` అమలు చేయవలసిన ఫంక్షన్.
• `getStore()` మెథడ్: ప్రస్తుత అసమకాలిక కాంటెక్స్ట్‌తో అనుబంధించబడిన డేటాను తిరిగి పొందుతుంది. కాంటెక్స్ట్ యాక్టివ్‌గా లేకపోతే `undefined` తిరిగి ఇస్తుంది.
• `enterWith(store)` మెథడ్: అందించిన స్టోర్‌తో స్పష్టంగా ఒక కాంటెక్స్ట్‌లోకి ప్రవేశిస్తుంది. జాగ్రత్తగా ఉపయోగించండి, ఎందుకంటే ఇది కోడ్‌ను అనుసరించడం కష్టతరం చేస్తుంది.
• `disable()` మెథడ్: AsyncLocalStorage ఇన్‌స్టాన్స్‌ను నిలిపివేస్తుంది.

ఆచరణాత్మక ఉదాహరణలు మరియు కోడ్ స్నిప్పెట్స్

జావాస్క్రిప్ట్ అప్లికేషన్‌లలో అసింక్ లోకల్ స్టోరేజ్‌ను ఎలా ఉపయోగించాలో కొన్ని ఆచరణాత్మక ఉదాహరణలను అన్వేషిద్దాం.

ప్రాథమిక వినియోగం

ఈ ఉదాహరణ ఒక సాధారణ దృష్టాంతాన్ని ప్రదర్శిస్తుంది, ఇక్కడ మేము ఒక అసమకాలిక కాంటెక్స్ట్‌లో రిక్వెస్ట్ IDని నిల్వ చేస్తాము మరియు తిరిగి పొందుతాము.

const { AsyncLocalStorage } = require('async_hooks');

const asyncLocalStorage = new AsyncLocalStorage();

function processRequest(req, res) {
  const requestId = Math.random().toString(36).substring(2, 15);

  asyncLocalStorage.run({ requestId }, () => {
    // అసమకాలిక ఆపరేషన్లను అనుకరించండి
    setTimeout(() => {
      const currentContext = asyncLocalStorage.getStore();
      console.log(`Request ID: ${currentContext.requestId}`);
      res.end(`Request processed with ID: ${currentContext.requestId}`);
    }, 100);
  });
}

// వచ్చే రిక్వెస్ట్‌లను అనుకరించండి
const http = require('http');

const server = http.createServer((req, res) => {
  processRequest(req, res);
});

server.listen(3000, () => {
  console.log('Server listening on port 3000');
});

Express.js మిడిల్‌వేర్‌తో ALS ఉపయోగించడం

ఈ ఉదాహరణ రిక్వెస్ట్-నిర్దిష్ట సమాచారాన్ని సంగ్రహించడానికి మరియు రిక్వెస్ట్ జీవితచక్రం అంతటా అందుబాటులో ఉంచడానికి Express.js మిడిల్‌వేర్‌తో ALSను ఎలా ఇంటిగ్రేట్ చేయాలో చూపిస్తుంది.

const express = require('express');
const { AsyncLocalStorage } = require('async_hooks');

const app = express();
const asyncLocalStorage = new AsyncLocalStorage();

// రిక్వెస్ట్ IDని సంగ్రహించడానికి మిడిల్‌వేర్
app.use((req, res, next) => {
  const requestId = Math.random().toString(36).substring(2, 15);
  asyncLocalStorage.run({ requestId }, () => {
    next();
  });
});

// రూట్ హ్యాండ్లర్
app.get('/', (req, res) => {
  const currentContext = asyncLocalStorage.getStore();
  const requestId = currentContext.requestId;
  console.log(`Handling request with ID: ${requestId}`);
  res.send(`Request processed with ID: ${requestId}`);
});

app.listen(3000, () => {
  console.log('Server listening on port 3000');
});

అధునాతన వినియోగ సందర్భం: డిస్ట్రిబ్యూటెడ్ ట్రేసింగ్

డిస్ట్రిబ్యూటెడ్ ట్రేసింగ్ సందర్భాలలో ALS ముఖ్యంగా ఉపయోగపడుతుంది, ఇక్కడ మీరు బహుళ సేవలు మరియు అసమకాలిక ఆపరేషన్లలో ట్రేస్ IDలను ప్రచారం చేయాలి. ఈ ఉదాహరణ ALS ఉపయోగించి ట్రేస్ IDని ఎలా ఉత్పత్తి చేసి, ప్రచారం చేయాలో చూపిస్తుంది.

const { AsyncLocalStorage } = require('async_hooks');
const { v4: uuidv4 } = require('uuid');

const asyncLocalStorage = new AsyncLocalStorage();

function generateTraceId() {
  return uuidv4();
}

function withTrace(callback) {
  const traceId = generateTraceId();
  asyncLocalStorage.run({ traceId }, callback);
}

function getTraceId() {
  const store = asyncLocalStorage.getStore();
  return store ? store.traceId : null;
}

// ఉదాహరణ వినియోగం
withTrace(() => {
  const traceId = getTraceId();
  console.log(`Trace ID: ${traceId}`);

  // అసమకాలిక ఆపరేషన్‌ను అనుకరించండి
  setTimeout(() => {
    const nestedTraceId = getTraceId();
    console.log(`Nested Trace ID: ${nestedTraceId}`); // అదే ట్రేస్ ID అయి ఉండాలి
  }, 50);
});

వాస్తవ-ప్రపంచ వినియోగ సందర్భాలు

అసింక్ లోకల్ స్టోరేజ్ అనేది వివిధ సందర్భాలలో వర్తించగల ఒక బహుముఖ సాధనం:

• లాగింగ్: రిక్వెస్ట్ ID, యూజర్ ID, లేదా ట్రేస్ ID వంటి రిక్వెస్ట్-నిర్దిష్ట సమాచారంతో లాగ్ సందేశాలను సుసంపన్నం చేయండి.
• ప్రామాణీకరణ మరియు అధికారికత: వినియోగదారు ప్రామాణీకరణ కాంటెక్స్ట్‌ను నిల్వ చేసి, రిక్వెస్ట్ జీవితచక్రం అంతటా యాక్సెస్ చేయండి.
• డేటాబేస్ లావాదేవీలు: నిర్దిష్ట రిక్వెస్ట్‌లతో డేటాబేస్ లావాదేవీలను అనుబంధించండి, డేటా స్థిరత్వం మరియు వేరుచేయడాన్ని నిర్ధారిస్తుంది.
• లోపం నిర్వహణ: రిక్వెస్ట్-నిర్దిష్ట లోపం కాంటెక్స్ట్‌ను సంగ్రహించి, వివరణాత్మక లోపం రిపోర్టింగ్ మరియు డీబగ్గింగ్ కోసం ఉపయోగించండి.
• A/B టెస్టింగ్: ప్రయోగ కేటాయింపులను నిల్వ చేసి, వినియోగదారు సెషన్ అంతటా వాటిని స్థిరంగా వర్తించండి.

పరిగణనలు మరియు ఉత్తమ పద్ధతులు

అసింక్ లోకల్ స్టోరేజ్ గణనీయమైన ప్రయోజనాలను అందిస్తున్నప్పటికీ, దానిని తెలివిగా ఉపయోగించడం మరియు ఉత్తమ పద్ధతులను పాటించడం చాలా అవసరం:

• పనితీరు ఓవర్‌హెడ్: అసమకాలిక కాంటెక్స్ట్‌ల సృష్టి మరియు నిర్వహణ కారణంగా ALS ఒక చిన్న పనితీరు ఓవర్‌హెడ్‌ను పరిచయం చేస్తుంది. మీ అప్లికేషన్‌పై ప్రభావాన్ని కొలవండి మరియు తదనుగుణంగా ఆప్టిమైజ్ చేయండి.
• కాంటెక్స్ట్ కాలుష్యం: మెమరీ లీక్స్ మరియు పనితీరు క్షీణతను నివారించడానికి ALSలో అధిక మొత్తంలో డేటాను నిల్వ చేయడం నివారించండి.
• స్పష్టమైన కాంటెక్స్ట్ నిర్వహణ: కొన్ని సందర్భాల్లో, ప్రత్యేకించి సంక్లిష్టమైన లేదా లోతుగా ఉన్న ఆపరేషన్ల కోసం, కాంటెక్స్ట్ ఆబ్జెక్ట్‌లను స్పష్టంగా పంపడం మరింత సముచితంగా ఉండవచ్చు.
• ఫ్రేమ్‌వర్క్ ఇంటిగ్రేషన్: లాగింగ్ మరియు ట్రేసింగ్ వంటి సాధారణ పనుల కోసం ALS మద్దతును అందించే ఇప్పటికే ఉన్న ఫ్రేమ్‌వర్క్ ఇంటిగ్రేషన్‌లు మరియు లైబ్రరీలను ఉపయోగించుకోండి.
• లోపం నిర్వహణ: కాంటెక్స్ట్ లీక్‌లను నివారించడానికి మరియు ALS కాంటెక్స్ట్‌లు సరిగ్గా శుభ్రపరచబడతాయని నిర్ధారించుకోవడానికి సరైన లోపం నిర్వహణను అమలు చేయండి.

అసింక్ లోకల్ స్టోరేజ్‌కు ప్రత్యామ్నాయాలు

ALS ఒక శక్తివంతమైన సాధనం అయినప్పటికీ, ఇది ప్రతి పరిస్థితికి ఉత్తమమైనది కాదు. ఇక్కడ పరిగణించవలసిన కొన్ని ప్రత్యామ్నాయాలు ఉన్నాయి:

• స్పష్టమైన కాంటెక్స్ట్ పాసింగ్: ఆర్గ్యుమెంట్‌లుగా కాంటెక్స్ట్ ఆబ్జెక్ట్‌లను పంపే సాంప్రదాయ విధానం. ఇది మరింత స్పష్టంగా మరియు తార్కికంగా సులభంగా ఉండవచ్చు, కానీ ఇది పెద్ద కోడ్‌కు కూడా దారితీయవచ్చు.
• డిపెండెన్సీ ఇంజెక్షన్: కాంటెక్స్ట్ మరియు డిపెండెన్సీలను నిర్వహించడానికి డిపెండెన్సీ ఇంజెక్షన్ ఫ్రేమ్‌వర్క్‌లను ఉపయోగించండి. ఇది కోడ్ మాడ్యులారిటీ మరియు పరీక్షనీయతను మెరుగుపరుస్తుంది.
• కాంటెక్స్ట్ వేరియబుల్స్ (TC39 ప్రపోజల్): కాంటెక్స్ట్‌ను నిర్వహించడానికి మరింత ప్రామాణిక మార్గాన్ని అందించే ఒక ప్రతిపాదిత ECMAScript ఫీచర్. ఇప్పటికీ అభివృద్ధిలో ఉంది మరియు ఇంకా విస్తృతంగా మద్దతు లేదు.
• కస్టమ్ కాంటెక్స్ట్ మేనేజ్‌మెంట్ సొల్యూషన్స్: మీ నిర్దిష్ట అప్లికేషన్ అవసరాలకు అనుగుణంగా కస్టమ్ కాంటెక్స్ట్ మేనేజ్‌మెంట్ సొల్యూషన్స్‌ను అభివృద్ధి చేయండి.

AsyncLocalStorage.enterWith() మెథడ్

`enterWith()` మెథడ్ `run()` ద్వారా అందించబడిన ఆటోమేటిక్ ప్రచారాన్ని దాటవేసి, ALS కాంటెక్స్ట్‌ను సెట్ చేయడానికి మరింత ప్రత్యక్ష మార్గం. అయితే, దీనిని జాగ్రత్తగా ఉపయోగించాలి. సాధారణంగా `run()` ఉపయోగించి కాంటెక్స్ట్‌ను నిర్వహించడం సిఫార్సు చేయబడింది, ఎందుకంటే ఇది అసమకాలిక ఆపరేషన్ల అంతటా కాంటెక్స్ట్ ప్రచారాన్ని స్వయంచాలకంగా నిర్వహిస్తుంది. `enterWith()` జాగ్రత్తగా ఉపయోగించకపోతే ఊహించని ప్రవర్తనకు దారితీయవచ్చు.

const { AsyncLocalStorage } = require('async_hooks');

const asyncLocalStorage = new AsyncLocalStorage();

const store = { data: 'Some Data' };

// enterWith ఉపయోగించి స్టోర్‌ను సెట్ చేయడం
asyncLocalStorage.enterWith(store);

// స్టోర్‌ను యాక్సెస్ చేయడం (enterWith తర్వాత వెంటనే పని చేయాలి)
console.log(asyncLocalStorage.getStore());

// కాంటెక్స్ట్‌ను స్వయంచాలకంగా వారసత్వంగా పొందని ఒక అసమకాలిక ఫంక్షన్‌ను ఎగ్జిక్యూట్ చేయడం
setTimeout(() => {
  // మేము enterWithతో మాన్యువల్‌గా సెట్ చేసినందున కాంటెక్స్ట్ ఇక్కడ ఇంకా యాక్టివ్‌గా ఉంది.
  console.log(asyncLocalStorage.getStore());
}, 1000);

// కాంటెక్స్ట్‌ను సరిగ్గా క్లియర్ చేయడానికి, మీకు try...finally బ్లాక్ అవసరం
// ఇది run() ఎందుకు సాధారణంగా ప్రాధాన్యత ఇవ్వబడుతుందో చూపిస్తుంది, ఎందుకంటే ఇది క్లీనప్‌ను స్వయంచాలకంగా నిర్వహిస్తుంది.

సాధారణ ఆపదలు మరియు వాటిని ఎలా నివారించాలి

• `run()` ఉపయోగించడం మర్చిపోవడం: మీరు AsyncLocalStorageను ప్రారంభించి, మీ రిక్వెస్ట్ హ్యాండ్లింగ్ లాజిక్‌ను `asyncLocalStorage.run()` లోపల ఉంచడం మర్చిపోతే, కాంటెక్స్ట్ సరిగ్గా ప్రచారం చేయబడదు, `getStore()`ని పిలిచినప్పుడు `undefined` విలువలకు దారితీస్తుంది.
• ప్రామిస్‌లతో తప్పు కాంటెక్స్ట్ ప్రచారం: ప్రామిస్‌లను ఉపయోగిస్తున్నప్పుడు, మీరు `run()` కాల్‌బ్యాక్ లోపల అసమకాలిక ఆపరేషన్ల కోసం వేచి ఉన్నారని నిర్ధారించుకోండి. మీరు వేచి ఉండకపోతే, కాంటెక్స్ట్ సరిగ్గా ప్రచారం చేయబడకపోవచ్చు.
• మెమరీ లీక్స్: AsyncLocalStorage కాంటెక్స్ట్‌లో పెద్ద ఆబ్జెక్ట్‌లను నిల్వ చేయడం నివారించండి, ఎందుకంటే కాంటెక్స్ట్ సరిగ్గా శుభ్రం చేయబడకపోతే అవి మెమరీ లీక్‌లకు దారితీయవచ్చు.
• AsyncLocalStorageపై అతిగా ఆధారపడటం: AsyncLocalStorageను గ్లోబల్ స్టేట్ మేనేజ్‌మెంట్ పరిష్కారంగా ఉపయోగించవద్దు. ఇది రిక్వెస్ట్-స్కోప్డ్ కాంటెక్స్ట్ నిర్వహణకు ఉత్తమంగా సరిపోతుంది.

జావాస్క్రిప్ట్‌లో కాంటెక్స్ట్ మేనేజ్‌మెంట్ యొక్క భవిష్యత్తు

జావాస్క్రిప్ట్ పర్యావరణ వ్యవస్థ నిరంతరం అభివృద్ధి చెందుతోంది మరియు కాంటెక్స్ట్ నిర్వహణకు కొత్త విధానాలు ఆవిర్భవిస్తున్నాయి. ప్రతిపాదిత కాంటెక్స్ట్ వేరియబుల్స్ ఫీచర్ (TC39 ప్రపోజల్) కాంటెక్స్ట్‌ను నిర్వహించడానికి మరింత ప్రామాణికమైన మరియు భాష-స్థాయి పరిష్కారాన్ని అందించాలని లక్ష్యంగా పెట్టుకుంది. ఈ ఫీచర్లు పరిపక్వం చెంది, విస్తృత ఆమోదం పొందినప్పుడు, అవి జావాస్క్రిప్ట్ అప్లికేషన్‌లలో కాంటెక్స్ట్‌ను నిర్వహించడానికి మరింత సొగసైన మరియు సమర్థవంతమైన మార్గాలను అందించవచ్చు.

ముగింపు

జావాస్క్రిప్ట్ అసింక్ లోకల్ స్టోరేజ్ అసమకాలిక వాతావరణంలో రిక్వెస్ట్-స్కోప్డ్ కాంటెక్స్ట్‌ను నిర్వహించడానికి ఒక శక్తివంతమైన మరియు సొగసైన పరిష్కారాన్ని అందిస్తుంది. కాంటెక్స్ట్ నిర్వహణను సరళీకరించడం, కోడ్ నిర్వహణను మెరుగుపరచడం మరియు డీబగ్గింగ్ సామర్థ్యాలను పెంచడం ద్వారా, ALS Node.js అప్లికేషన్‌ల కోసం అభివృద్ధి అనుభవాన్ని గణనీయంగా మెరుగుపరుస్తుంది. అయినప్పటికీ, మీ ప్రాజెక్ట్‌లలో ALSను స్వీకరించడానికి ముందు ప్రధాన భావనలను అర్థం చేసుకోవడం, ఉత్తమ పద్ధతులను పాటించడం మరియు సంభావ్య పనితీరు ఓవర్‌హెడ్‌ను పరిగణనలోకి తీసుకోవడం చాలా ముఖ్యం. జావాస్క్రిప్ట్ పర్యావరణ వ్యవస్థ అభివృద్ధి చెందుతూనే ఉన్నందున, కాంటెక్స్ట్ నిర్వహణకు కొత్త మరియు మెరుగైన విధానాలు ఉద్భవించవచ్చు, సంక్లిష్ట అసమకాలిక దృష్టాంతాలను నిర్వహించడానికి మరింత అధునాతన పరిష్కారాలను అందిస్తాయి.